def train_model(df1, is_regression, target_value, test_size_percent):
"""
train_model function removes features that aren't needed for model training.
:param df1: Pandas dataframe object
:param is_regression: model to be trained as regressor or classifier
:param target_value: target output
:param test_size_percent: the proportion of the dataset to include in the test split.
:return list of trained models with metrics
"""
model_details,param_details,train_model_lists={},{},[]
X,y=sm.fit_resample(df1.drop(target_value, axis=1), df1[target_value])
X_train,X_test,y_train,y_test=train_test_split(X, y, test_size=test_size_percent/100, random_state=42)
if is_regression:
model_details={
'Linear_Regression': LinearRegression(),
'Ridge_Regression': Ridge(random_state=42),
'Lasso_Regression': Lasso(random_state=42),
'KNN_Regression': KNeighborsRegressor(),
'SVM_Regression': SVR(),
'DecisionTree_Regression': DecisionTreeRegressor(random_state=42),
'RandomForest_Regression': RandomForestRegressor(random_state=42),
'GradientBoosting_Regression': GradientBoostingRegressor(random_state=42),
'AdaBoost_Regression': AdaBoostRegressor(random_state=42),
'XGB_Regression': XGBRegressor(random_state=42)
}
param_details={
'Linear_Regression': {},
'Ridge_Regression': {'alpha': np.logspace(-8, 8, 100), 'fit_intercept': [True, False], 'solver': ['svd', 'cholesky', 'lsqr', 'sparse_cg', 'sag', 'saga']},
'Lasso_Regression': {'alpha': np.logspace(-8, 8, 100)},
'KNN_Regression':{'n_neighbors': np.arange(1,int(np.sqrt(len(X_train)))).tolist(),'p': [1,2],'weights': ['uniform','distance']},
'SVM_Regression': {'kernel':['linear','rbf'],'C':[0.1,1,10,100],'gamma':[1,0.1,0.001]},
'DecisionTree_Regression': {'criterion':['squared_error','friedman_mse','absolute_error','poisson'],'min_samples_split':[10,20,40],'max_depth':[2,6,8],'min_samples_leaf':[20,40,100],'max_leaf_nodes':[5,20,100]},
'RandomForest_Regression': {'max_depth': [5,10,None], 'max_features': ['sqrt','log2',None], 'n_estimators': [5,6,7,8,9,10,11,12,13,15]},
'GradientBoosting_Regression': {'learning_rate': [0.05,0.10,0.15],'min_samples_split': np.linspace(0.1,0.5,6),'min_samples_leaf': np.linspace(0.1,0.5,6),'max_depth':[3,5,8],'max_features':['log2','sqrt'],'subsample':[0.5,1.0],'n_estimators':[20,40,50,60]},
'AdaBoost_Regression': {'n_estimators': [20,40,50,60],'learning_rate': [0.05,0.10,0.15]},
'XGB_Regression': {'learning_rate':[0.05,0.10,0.15],'max_depth':[3,4,5,6],'min_child_weight':[1,3,5],'gamma':[0.1,0.2,0.3],'colsample_bytree':[0.3,0.4,0.5],'n_estimators':[20,40,50,60]}
}
else:
model_details={
'KNN_Classifier': KNeighborsClassifier(),
'SVM_Classifier': SVC(random_state=42),
'XGB_Classifier': XGBClassifier(random_state=42),
'GaussianNB': GaussianNB(),
'GradientBoosting_Classifier': GradientBoostingClassifier(random_state=42),
'AdaBoost_Classifier': AdaBoostClassifier(random_state=42),
'RandomForest_Classifier': RandomForestClassifier(random_state=42),
'DecisionTree_Classifier': DecisionTreeClassifier(random_state=42),
}
param_details={
'KNN_Classifier': {'n_neighbors': np.arange(1,int(np.sqrt(len(X_train)))).tolist(), 'p': [1,2]},
'SVM_Classifier': {'C':[0.1,1,10,100],'gamma':[1,0.1,0.001], 'kernel':['linear','rbf']},
'XGB_Classifier': {'learning_rate':[0.05,0.10,0.15],'max_depth':[3,4,5,6],'min_child_weight':[1,3,5],'gamma':[0.1,0.2,0.3],'colsample_bytree':[0.3,0.4,0.5],'n_estimators':[20,40,50,60]},
'GaussianNB': {'var_smoothing': np.logspace(0,-9, num=100)},
'GradientBoosting_Classifier': {'learning_rate': [0.05,0.10,0.15],'min_samples_split': np.linspace(0.1,0.5,6),'min_samples_leaf': np.linspace(0.1,0.5,6),'max_depth':[3,5,8],'max_features':['log2','sqrt'],'subsample':[0.5,1.0],'n_estimators':[20,40,50,60]},
'AdaBoost_Classifier': {'n_estimators': [20,40,50,60],'learning_rate': [0.05,0.10,0.15]},
'RandomForest_Classifier': {'n_estimators': [20,40,50,60],'max_depth' : [4,5,6,7,8],'criterion' :['gini','entropy']},
'DecisionTree_Classifier': {'ccp_alpha': [0.1,.01,.001],'max_depth': [5, 6, 7, 8, 9],'criterion' :['gini', 'entropy']},
}
for key in model_details.keys():
print("Running GridSearchCV for %s." % key)
grid_search = GridSearchCV(model_details.get(key), param_details.get(key), cv=3, n_jobs=3, refit=True)
grid_search.fit(X_train,y_train)
predicted_model=grid_search.best_estimator_
predicted_model.fit(X_train,y_train)
y_pred = predicted_model.predict(X_test)
y_train_pred = predicted_model.predict(X_train)
if is_regression:
train_model_lists.append([key, predicted_model.score(X_train,y_train), predicted_model.score(X_test,y_test),
mean_absolute_error(y_test,y_pred), mean_squared_error(y_test,y_pred), np.sqrt(mean_squared_error(y_test,y_pred)), r2_score(y_test, y_pred), predicted_model])
else:
train_model_lists.append([key, accuracy_score(y_train,y_train_pred), accuracy_score(y_test, y_pred),
roc_auc_score(y_test,y_pred), precision_score(y_test,y_pred), recall_score(y_test,y_pred), f1_score(y_test,y_pred), predicted_model])
print("GridSearchCV for %s completed." % key)
return train_model_lists
